perm filename APP5[AIM,DBL]2 blob
sn#125920 filedate 1974-10-22 generic text, type T, neo UTF8
00100 .DEVICE XGP
00200 .FONT 1 "FIX25"
00300 .FONT 2 "SIGN57"
00400 .FONT 3 "SHD40"
00500 .FONT 4 "BDI25"
00600 .FONT 5 "NGB30"
00700 .FONT 6 "NGR20"
00800 .PAGE FRAME 53 HIGH 77 WIDE
00900 .TURN ON "↓_π{"
01000 .TURN ON "\" FOR "%"
01100 .MACRO B ⊂ BEGIN VERBATIM GROUP ⊃
01200 .MACRO E ⊂ APART END ⊃
01300 .TABBREAK
01400 .COMPACT
01500 .EVERY FOOTING(\6Fourth Draft .... {DATE},page A5.{IF PAGE = 1 THEN 1 ELSE PAGE},User/PUP6 Dialogue excerpts\*)
01600 .EVERY HEADING(\3BEINGS\*,,\4Doug Lenat\*)
01700 .COUNT PAGE PRINTING "1"
01800 .NEXT PAGE
01900
02000 \2APPENDIX 5. \* \3CF .... DIALOGUE\*
02100 .B
02200
02300
02400 .E
02500
02600 Here are fragments of the dialogue which the user went through with
02700 PUP6 to generate the CF program.
02800 Keep in mind that the entire dialogue occupied half a million characters,
02900 so only 3% of it is presented here. Even these numbers are deceptively
03000 small; they assume the user never interrupts. If he does, the size of the
03100 interaction can swell
03200 by two orders of magnitude! As an example of this, a
03300 four line long patch of the dialogue, near the beginning, was re-run in
03400 a mode which allowed the user to interrupt after each BEING transferred
03500 control, and query (ask some of the thirty questions) BEINGs as they ran.
03600 The duplicated patch is set off by rows of asterisks, on page A5.2.
03700 As usual, the user's reponses are \4ITALICIZED\*,
03800 and the author's meta-comments are in \5LARGE, BOLD type\*.
03900 Frequently, the user is asked to pick a name for a new BEING. He is
04000 presented with a set of plausible choices, from which he may deviate.
04100 This verbosity obscures the heart of the dialogue, so only the first
04200 such naming is tolerated below; the others were deleted.
04300 Names of new, specialized
04400 versions of existing BEINGs are typically suffixed
04500 by a number. The colon (:) is used like a hyphen below, for unimportant
04600 reasons.
00100 .NOFILL
00200
00300
00400
00500 ←\4ENTER(T)\*
00600
00700 USER INTERRUPT LEVEL... \40\*
00800
00900 PUP: (PUP WANTS ANY TASK)
01000
01100
01200 USER: \4(WRITE A PROGRAM WHICH DOES CONCEPT FORMATION)\*
01300
01400 PUP: (PUP IS ABOUT TO WRITE A PROGRAM TO DO (CONCEPT:FORMATION))
01500
01600
01700 PUP: ((C:F CONCEPT:FORMATION C CF) IS THE SET OF PLAUSIBLE NAMES OF
01800 (CONCEPT FORMATION) WHICH IS AN EXPANSION OF
01900 CONCEPT:FORMATION)
02000
02100 PUP: (PUP WANTS USER TO TYPE IN NAME FOR (CONCEPT:FORMATION))
02200
02300 I DON'T KNOW ANY NAMES FOR ( CONCEPT:FORMATION), SO YOU'LL HAVE TO
02400 TYPE A BRAND NEW NAME IN TO ME.
02500
02600 USER: \4CF\*
02700
02800 PUP: (PUP AND USER ARE ABLE TO REFER TO (CONCEPT:FORMATION) AS CF:1)
02900
03000 PUP: (THE NAME OF THE PROGRAM TO DO (CONCEPT:FORMATION) IS CF:1)
03100
03200 \5*************************************************************\*
03300
03400 MOVE CURSOR TO ( CF:1 TYPE OF ( CONCEPT:FORMATION))
03500
03600 SORRY TO BOTHER YOU, BUT I CAN NO LONGER DEFER THIS BOOLEAN DECISION:
03700 (SUBJECT:SPECIFIC BEHAVIOR MAY BE REQUIRED OF CF:1)
03800 SINCE THE DECISION IS BOOLEAN, JUST ANSWER YES OR NO.
03900 SHOULD I DISCUSS RAMIFICATIONS?\4NO\*
04000
04100 NOW TYPE YOUR ANSWER: \4NO\*
04200
04300 OK, READY TO MOVE ON NOW.
04400
04500 \5*************************************************************\*
04600
04700
04800 PUP IS NOW GOING TO ENCODE THE PIECE
04900 (TEMPORARILY (PARTITION:A:DOMAIN))
05000 OF THE FUNCTION CF:1 INTO LISP. FUNCTION NAMES WILL
05100 BE QUERIED IN PREORDER, AS NEEDED.
05200
05300 DRAW A LINE FROM THE FUNCTION CALL NIL OF THE FUNCTION CF:1 TO THIS NEW
05400 PIECE OF CODE, WHICH IS ITS BODY:
05500
05600 (CF:1
05700 (LAMBDA (DUMMY:ARGUMENT:3 DUMMY:ARGUMENT:2 DUMMY:ARGUMENT:1)
05800 (TEMPORARILY (PAD:2))))
05900
06000 (CF:1 redefined)
06100 .FILL
06200 \5 The "piece of code" is now just the META:CODE of the new BEING
06300 CF:1. Other parts have been filled in, so it is no longer defined as
06400 above. The full, long definition contains much bookkeeping but
06500 nothing of relevance to tell the user. The "function call NIL"
06600 mentioned above indicates that CF:1 is the topmost function; it is
06700 not called by any other. \*
06800 .NOFILL
06900
07000 MOVE CURSOR TO ( PAD:2 TYPE OF ( PARTITION:A:DOMAIN))
07100
07200 SORRY TO BOTHER YOU, BUT I CAN NO LONGER DEFER THIS SOMEOF DECISION:
07300 (PARTITION:BY:TAKE:ELE:AND:CLASS
07400 PARTITION:BY:TAKE:CLASS:GET:ELE
07500 PARTITION:BY:TAKE:ELE:GET:CLASS)
07600 SINCE THE DECISION IS SOME:OF, TYPE ANY ORDERED SUBSET OF:
07700 (A .... PARTITION:BY:TAKE:ELE:AND:CLASS)
07800 (B .... PARTITION:BY:TAKE:CLASS:GET:ELE)
07900 (C .... PARTITION:BY:TAKE:ELE:GET:CLASS)
08000
08100 FOR EXAMPLE, (B D) WOULD MEAN THAT THE 2ND AND 4TH ITEMS ARE RELEVANT
08200
08300 SHOULD I DISCUSS RAMIFICATIONS?\4NO\*
08400 \5<TAKE involves trivial accessing or reading in;
08500 GET involves working to obtain, e.g., by searching or computing>\*
08600
08700 USER: \4(A C)\*
08800
08900 AT THIS POINT, I ALMOST RECOMMENDED VIRTUAL STRUCTURING, BUT DECIDED
09000 AGAINST IT. THE LIST STRUCTURE WOULD HAVE BEEN DIVIDED INTO THESE
09100 PIECES: (PARTITION:BY:TAKE:ELE:AND:CLASS:PART:OF:NIL
09200 PARTITION:BY:TAKE:ELE:GET:CLASS:PART:OF:NIL)
09300 (I GUESS THAT EACH OF THE ABOVE :NIL-S WOULD GET REPLACED BY SOMETHING
09400 LIKE ":PARTITION:LIST")
09500
09600 PUP IS NOW GOING TO ENCODE THE PIECE
09700 (REPEATEDLY (TAKE:HOLD:OF ELEMENT)
09800 (COND ((IS:OF:TYPE ELEMENT (COMMENT PARTITION:BY:TAKE:ELE:
09900 -AND:CLASS))
10000 (TAKE:HOLD:OF NAME:OF:CLASS)
10100 (MODIFY:STRUCTURE NAME:OF:CLASS))
10200 (T
10300 (GET:HOLD:OF NAME:OF:CLASS)
10400 (MODIFY:STRUCTURE NAME:OF:CLASS))))
10500
10600 OF THE FUNCTION PAD:2 INTO LISP. FUNCTION NAMES WILL
10700 BE QUERIED IN PREORDER, AS NEEDED.
10800
10900 PUP WANTS USER TO TYPE IN NAME FOR ( TAKE:HOLD:OF)
11000 THE NAME CHOSEN IS TAKE:HOLD:OF:3
11100
11200 PUP WANTS USER TO TYPE IN NAME FOR ( ELEMENT)
11300 THE NAME CHOSEN IS ELEMENT:4
11400
11500 PUP WANTS USER TO TYPE IN NAME FOR ( IS:OF:TYPE)
11600 THE NAME CHOSEN IS HAS:NAME:5
11700
11800 PUP WANTS USER TO TYPE IN NAME FOR ( ELEMENT)
11900 IS THIS THE SAME AS A ( ELEMENT) WHICH WE'VE ALREADY SEEN AND NAMED?
12000
12100 USER: \4YES\*
12200
12300 SINCE ELEMENT:4 IS THE ONLY NAME FOR ( ELEMENT),
12400 AT LEAST AS FAR AS PUP KNOWS RIGHT NOW, PUP ASSUMES THAT IS THE ONE
12500 YOU WANT. AM I RIGHT?
12600 USER: \4YES\*
12700
12800 THE NAME CHOSEN IS ELEMENT:4
12900
13000 PUP WANTS USER TO TYPE IN NAME FOR ( TAKE:HOLD:OF)
13100 THE NAME CHOSEN IS TAKE:HOLD:OF:6
13200
13300 PUP WANTS USER TO TYPE IN NAME FOR ( MODIFY:STRUCTURE)
13400 THE NAME CHOSEN IS MODIFY:STRUCTURE:7
13500
13600 PUP WANTS USER TO TYPE IN NAME FOR ( GET:HOLD:OF)
13700 THE NAME CHOSEN IS GET:HOLD:OF:8
13800
13900 PUP WANTS USER TO TYPE IN NAME FOR ( MODIFY:STRUCTURE)
14000 THE NAME CHOSEN IS MODIFY:STRUCTURE:9
14100
14200 \5<from now on, even this level of naming detail will be omitted.>\*
14300
14400 DRAW A LINE FROM THE FUNCTION CALL (PAD:2) OF THE FUNCTION PAD:2 TO THIS
14500 NEW PIECE OF CODE, WHICH IS ITS BODY:
14600
14700 (PAD:2
14800 (LAMBDA (DUMMY:ARGUMENT:3 DUMMY:ARGUMENT:2 DUMMY:ARGUMENT:1)
14900 (PROG NIL
15000 LABEL:1
15100 (TAKE:HOLD:OF:3 ELEMENT:4)
15200 (COND
15300 ((HAS:NAME:5 ELEMENT:4 (COMMENT PARTITION:BY:TAKE:ELE:
15400 -AND:CLASS))
15500 (TAKE:HOLD:OF:6 NAME:OF:CLASS)
15600 (MODIFY:STRUCTURE:7 NAME:OF:CLASS))
15700 (T
15800 (GET:HOLD:OF:8 NAME:OF:CLASS)
15900 (MODIFY:STRUCTURE:9 NAME:OF:CLASS)))
16000 (GO LABEL:1)
16100 (COMMENT INFINITE LOOP IN THIS PROG))))
16200
16300 (PAD:2 redefined) \5<as a BEING>\*
16400
16500 MOVE CURSOR TO ( ELEMENT:4 TYPE OF ( ELEMENT))
16600
16700 SORRY TO BOTHER YOU, BUT I CAN NO LONGER DEFER THIS DEFINITION
16800 DECISION: (WHAT IS AN ELEMENT)
16900 SINCE THE QUESTION IS ONE OF DEFINITION, PLEASE JUST
17000 TYPE IN THE DEFINITION OF ELEMENT:4
17100
17200 SHOULD I DISCUSS RAMIFICATIONS? \4NO\* \5<henceforth, this will be omitted>\*
17300
17400 USER: \4(A DESCRIPTION OF A STATIC SCENE)\*
17500
17600 DRAW A LINE FROM THE FUNCTION CALL (ELEMENT:4 (COMMENT PARTITION:BY:TAKE:
17700 -ELE:AND:CLASS))
17800 OF THE FUNCTION ELEMENT:4 TO THIS NEW PIECE OF CODE,
17900 WHICH IS ITS BODY:
18000
18100 (ELEMENT:4
18200 (LAMBDA (DUMMY:ARGUMENT:3 DUMMY:ARGUMENT:2 DUMMY:ARGUMENT:1)
18300 (STRUCTURE (OBJECTS SET O)
18400 (CLASS:NAME NAME N)
18500 (STATIC RELATIONS S BETWEEN OBJECTS))))
18600 (ELEMENT:4 redefined)
18700
18800 MOVE CURSOR TO ( HAS:NAME:5 TYPE OF ( IS:OF:TYPE))
18900
19000 SORRY TO BOTHER YOU, BUT I CAN NO LONGER DEFER THIS DEFINITION
19100 DECISION: (HOW DO WE KNOW WHEN THE 'IS:OF:TYPE'
19200 PREDICATE IS TRUE, AND WHEN IT IS FALSE?
19300 PUP ASSUMES THAT USER WILL TYPE IN A
19400 LOGICAL SENTENCE WHOSE TRUTH IS EQUIVALENT
19500 TO IT)
19600 SINCE THE QUESTION IS ONE OF DEFINITION, PLEASE JUST
19700 TYPE IN THE DEFINITION OF HAS:NAME:5
19800
19900 SINCE THIS IS A PREDICATE, THE EXPRESSION YOU TYPE IN SHOULD BE A
20000 LOGICAL EXPRESSION, WHICH IS TRUE IF ELEMENT:4 IS OF
20100 THE (PARTITION:BY:TAKE:ELE:AND:CLASS) TYPE,
20200 AND SHOULD BE FALSE IF IT ISNT
20300 OF THAT TYPE.
20400
20500 USER: \4(THE FRONT PART OF ARG1 ISNT ???)\*
20600
20700 (IS ??? A LITERAL CONSTANT (WHOSE VALUE SHOULD BE ITSELF) (REPLY YES OR
20800 NO, PLEASE) USER...)
20900 \4YES\*
21000
21100 PUP IS NOW GOING TO ENCODE THE PIECE
21200 (NOT (EQUAL (CAR ARG1)
21300 ???))
21400
21500
21600 OF THE FUNCTION HAS:NAME:5 INTO LISP. FUNCTION NAMES WILL
21700 BE QUERIED IN PREORDER, AS NEEDED.
21800
21900 DRAW A LINE FROM THE FUNCTION CALL (HAS:NAME:5 ELEMENT:4 (COMMENT PARTI
22000 -TION:BY:TAKE:ELE:AND:CLASS)) OF THE FUNCTION HAS:NAME:5 TO THIS NEW
22100 PIECE OF CODE, WHICH IS ITS BODY:
22200
22300 (HAS:NAME:5
22400 (LAMBDA (ARG1 DUMMY:ARGUMENT:2 DUMMY:ARGUMENT:1)
22500 (COMMENT IN ALL CALLS TO DATE, ARG1 IS INSTANTIATED AS ELEMENT:4)
22600 (NOT (EQUAL (CAR ARG1)
22700 ???))))
22800
22900
23000 (HAS:NAME:5 redefined)
23100
23200 MOVE CURSOR TO ( TAKE:HOLD:OF:3 TYPE OF ( TAKE:HOLD:OF))
23300
23400 SORRY TO BOTHER YOU, BUT I CAN NO LONGER DEFER THIS DICHOTOMY DECISION:
23500 ...HMMM...
23600
23700 AHA!!!! I'VE RESOLVED IT MYSELF!!! NO NEED TO INTERACT WITH THE SLOW
23800 USER CHANNEL AFTER ALL!!!
23900
24000 (PUP IS ABOUT TO ENCODE AN ASSIGNMENT: (OBJECTS SET O) WILL BE SET TO
24100 SOME PART OF ARG1 WHICH IS GOING TO BE
24200 INSTANTIATED DURING THE RUNNING OF THE PROGRAM AS ELEMENT:4
24300 PUP WANTS A NAME FOR THIS 'SOME PART OF' FUNCTION.)
24400
24500 DRAW A LINE FROM THE FUNCTION CALL (TAKE:HOLD:OF:3 ELEMENT:4) OF THE
24600 FUNCTION TAKE:HOLD:OF:3 TO THIS NEW PIECE OF CODE, WHICH IS ITS BODY:
24700
24800 (TAKE:HOLD:OF:3
24900 (NLAMBDA (ARG1)
25000 (COMMENT IN ALL CALLS TO DATE, ARG1 IS INSTANTIATED AS ELEMENT:4)
25100 (PROGN (PRINT (COMMENT READY TO ACCEPT BRAND NEW ELEMENT:4))
25200 (SET ARG1 (READ))
25300 (SETQ ELEMENT:OBJECTS:11 (SOME:PART:OF:12 (EVAL ARG1)))
25400 (SETQ ELEMENT:CLASSNAME:13 (SOME:PART:OF:14 (EVAL ARG1)))
25500 (SETQ ELEMENT:RELNS:15 (SOME:PART:OF:16 (EVAL ARG1)))
25600 T)))
25700
25800 (COMMENT NAME:OF:CLASS IS NOT A BEING YET)
25900
26000 MOVE CURSOR TO ( TAKE:HOLD:OF:6 TYPE OF ( TAKE:HOLD:OF))
26100
26200 (THE ASSIGNMENT WHICH SET NAME:OF:CLASS
26300 WAS DONE EARLIER; SHOULD A NEW VALUE OF
26400 NAME:OF:CLASS BE READ IN AT THIS POINT IN
26500 THE PROGRAM FLOW? USER...)
26600 \4NO\*
26700
26800 DRAW A LINE FROM THE FUNCTION CALL (TAKE:HOLD:OF:6 NAME:OF:CLASS) OF THE
26900 FUNCTION TAKE:HOLD:OF:6 TO THIS NEW PIECE OF CODE, WHICH IS ITS BODY:
27000
27100 (TAKE:HOLD:OF:6
27200 (NLAMBDA (ARG1)
27300 (COMMENT IN ALL CALLS TO DATE, ARG1 IS INSTANTIATED AS NAME:OF:CLASS)
27400 (PROGN (COMMENT NOTHING MUCH TO DO HERE; JUST ONE SIMPLE ASSIGNMENT
27500 TO AN ALREADY EXISTING VALUE)
27600 (SET ARG1 OBVIOUS:KNOWN:VALUE:OF:NAME:OF:CLASS))))
27700
27800 MOVE CURSOR TO ( GET:HOLD:OF:8 TYPE OF ( GET:HOLD:OF))
27900
28000 SORRY TO BOTHER YOU, BUT I CAN NO LONGER DEFER THIS SOMEOF DECISION:
28100 (COMPUTE SEARCH GENERATE:AND:TEST)
28200 SINCE THE DECISION IS SOME:OF, TYPE ANY ORDERED SUBSET OF:
28300 (A .... COMPUTE)
28400 (B .... SEARCH)
28500 (C .... GENERATE:AND:TEST)
28600
28700 USER: \4(B)\*
28800
28900
29000 YOU MUST GIVE ME A LIST OF ALL THE VALUES THAT COULD EVER OCCUR AS
29100 NAMES ON THE LIST STRUCTURE SET:OF:POSSIBLE:NAMES:OF:CLASS
29200
29300 IF THIS ISN'T MEANINGFUL, REPLY NIL.
29400
29500 USER: \4NIL\*
29600
29700 MOVE CURSOR TO ( GET:HOLD:OF:8 TYPE OF ( GET:HOLD:OF))
29800
29900 SORRY TO BOTHER YOU, BUT I CAN NO LONGER DEFER THIS BOOLEAN DECISION:
30000 (DOES AN ALGORITHM ALREADY EXIST WHICH GETS
30100 PRECISELY NAME:OF:CLASS)
30200 SINCE THE DECISION IS BOOLEAN, JUST ANSWER YES OR NO.
30300
30400 NOW TYPE YOUR ANSWER: \4NO\*
30500
30600 OK, READY TO MOVE ON NOW.
30700
30800 PUP IS NOW GOING TO ENCODE THE PIECE
30900 (PROGN (FOREACH POSSIBLE:NAME:OF:CLASS IN SET:OF:POSSIBLE:NAMES:OF:CLASS
31000 DO (TEST POSSIBLE:NAME:OF:CLASS
31100 (COMMENT FOR SATISFACTION OF GOAL CRITERIA)))
31200 (PRIN1 "
31300 MY GUESS FOR THIS IS ")
31400 (PRINT POSSIBLE:NAME:OF:CLASS))
31500
31600 OF THE FUNCTION GET:HOLD:OF:8 INTO LISP. FUNCTION NAMES WILL
31700 BE QUERIED IN PREORDER, AS NEEDED.
31800
31900 MOVE CURSOR TO ( FOREACH:17 TYPE OF ( FOREACH))
32000 SORRY TO BOTHER YOU, BUT I CAN NO LONGER DEFER THIS BOOLEAN DECISION:
32100 (I ASSUME THAT I STOP AFTER EXAMINING ALL
32200 POSSIBLE:NAMES:OF:CLASS IN SET:OF:POSSIBLE:NAMES:OF:CLASS ;
32300 DO I ALSO STOP AFTER SOME CONDITION 'C' BECOMES TRUE?)
32400 SINCE THE DECISION IS BOOLEAN, JUST ANSWER YES OR NO.
32500
32600 NOW TYPE YOUR ANSWER: \4YES\*
32700
32800 PLEASE TYPE IN A PREDICATE EQUIVALENT TO THIS UNTIL CONDITION 'C'.
32900 (TYPING IN ] WILL MEAN THAT THE CONDITION IS THAT RESULT:1
33000 IS NONNULL.)
33100
33200 USER: \4(TEST:18 SUCCEEDED)\*
33300
33400 OK, READY TO MOVE ON NOW.
33500
33600 DRAW A LINE FROM THE FUNCTION CALL (FOREACH:17 POSSIBLE:NAME:OF:CLASS IN
33700 SET:OF:POSSIBLE:NAMES:OF:CLASS DO (TEST:18 POSSIBLE:NAME:OF:CLASS
33800 (COMMENT FOR SATISFACTION OF GOAL CRITERIA)))
33900 OF THE FUNCTION FOREACH:17
34000 TO THIS NEW PIECE OF CODE, WHICH IS ITS BODY:
34100
34200 (FOREACH:17
34300 (NLAMBDA (ARG1 DUMMY:ARGUMENT:2 ARG3 DUMMY:ARGUMENT:1 ARG5)
34400 (COMMENT IN ALL CALLS TO DATE, ARG1 IS BOUND TO POSSIBLE:NAME
34500 :OF:CLASS)
34600 (COMMENT IN ALL CALLS TO DATE, ARG3 IS BOUND TO SET:OF:POSSIB
34700 -LE:NAMES:OF:CLASS)
34800 (COMMENT IN ALL CALLS TO DATE, ARG5 IS BOUND TO
34900 (COMMENT TEST:18 POSSIBLE:NAME:OF:CLASS
35000 (COMMENT FOR SATISFACTION OF GOAL CRITERIA)))
35100 (PROG (RESULT:1)
35200 (SETQ EVAL:ARG3 (EVAL ARG3))
35300 LABEL:2
35400 (COND
35500 ((NULL EVAL:ARG3)
35600 (SET ARG1 FAILURE:VALUE)
35700 (RETURN EXHAUSTION:VALUE)))
35800 (SET ARG1 (CAR EVAL:ARG3))
35900 (SETQ EVAL:ARG3 (CDR EVAL:ARG3))
36000 (SETQ RESULT:1 (EVAL ARG5))
36100 (COND
36200 ((NOT (EQUAL RESULT:1 NIL))
36300 (RETURN UNTIL:CONDITION:VALUE))
36400 (T (GO LABEL:2)))
36500 (COMMENT AT THE TIME THAT FOREACH:17 WAS CODED, THE UNTIL
36600 CONDITION VALUE WAS LEFT UNDEFINED))))
36700
36800 MOVE CURSOR TO ( TEST:18 TYPE OF ( TEST))
36900
37000 SORRY TO BOTHER YOU, BUT I CAN NO LONGER DEFER THIS BOOLEAN DECISION:
37100 (SHOULD WE IMPLEMENT ERROR RECOVERY IN ANY
37200 FANCY WAY)
37300 SINCE THE DECISION IS BOOLEAN, JUST ANSWER YES OR NO.
37400
37500 \4NO\*
37600
37700 NOTHING TO DO AT THIS TIME, THEN.
37800
37900 OK, READY TO MOVE ON NOW.
38000
38100 SORRY TO BOTHER YOU, BUT I CAN NO LONGER DEFER THIS DICHOTOMY DECISION:
38200 (( THE TESTING MAY HAVE THE CHARACTER
38300 OF COMPARING THE OBJECT ( THAT IS, ARG1, ALSO KNOWN AS
38400 ( CADDR ENT1)) WITH SOME DISTINGUISHED OBJECT)
38500 ( TESTING MAY HAVE THE CHARACTER OF LETTING THE OBJECT
38600 (WHICH IS ARG1) COMPETE WITH ITS FELLOW OBJECTS
38700 FOR SUPREMACY)
38800 ABOVE, ARG1 REFERS TO POSSIBLE:NAME:OF:CLASS )
38900
39000 AHA!!!! I'VE RESOLVED IT MYSELF!!! NO NEED TO INTERACT WITH THE SLOW
39100 USER CHANNEL AFTER ALL!!!
39200
39300 PUP IS NOW GOING TO ENCODE THE PIECE
39400 (COMPARE ARG1 ELEMENT:4)
39500
39600
39700 OF THE FUNCTION TEST:18 INTO LISP. FUNCTION NAMES WILL
39800 BE QUERIED IN PREORDER, AS NEEDED.
39900
40000 DRAW A LINE FROM THE FUNCTION CALL (COMPARE:19 ARG1 ELEMENT:4) OF THE
40100 FUNCTION COMPARE:19 TO THIS NEW PIECE OF CODE, WHICH IS ITS BODY:
40200
40300 (COMPARE:19
40400 (LAMBDA (ARG1 ARG2)
40500 (COMMENT IN ALL CALLS TO DATE, ARG1 IS INSTANTIATED AS POSSIBLE:NAME:
40600 -OF:CLASS)
40700 (COMMENT IN ALL CALLS TO DATE, ARG2 IS INSTANTIATED AS ELEMENT:4)
40800 ARG1
40900 ARG2
41000 (COMMENT ARG1 AND ARG2 ARE HERE SIMPLY TO CAUSE PUP
41100 TO STICK IN COMMENTS ABOUT THEIR INSTANTIATION)
41200 (JOIN:23 (COMPARE:24 POSSIBLE:NAME:OF:CLASS:OBJECTS:20
41300 ELEMENT:OBJECTS:11)
41400 (COMPARE:25 POSSIBLE:NAME:OF:CLASS:CLASSNAME:21
41500 ELEMENT:CLASSNAME:13)
41600 (COMPARE:26 POSSIBLE:NAME:OF:CLASS:RELNS:22
41700 ELEMENT:RELNS:15))))
41800
41900 .FILL
42000 \5Here begins one of the sections discussed on page 19 of this paper,
42100 the genesis of the MUSTNOT/MUST/MAY divisions. The names used
42200 here differ slightly from those in the body of the paper. The
42300 symbol # stands for "contradiction".\*
42400 .NOFILL
42500
42600 MOVE CURSOR TO ( JOIN:23 TYPE OF ( JOINING:FUNCTION))
42700
42800 SORRY TO BOTHER YOU, BUT I CAN NO LONGER DEFER THIS PREDICATE DECISION:
42900 (WHEN WE TERMINATE THE LOOP)
43000
43100 PLEASE TYPE IN A LOGICAL EXPRESSION WHICH IS TRUE ( WHEN WE TERMINATE
43200 THE LOOP) AND IS FALSE OTHERWISE.
43300
43400 USER: \4(ANY RELATION IN POSSIBLE:NAME:OF:CLASS:RELNS:22 IS INCOMPATIBLE
43500 WITH ELEMENT:RELNS:15)\*
43600
43700 PUP IS NOW GOING TO ENCODE THE PIECE
43800 (AND ARG1 ARG2 ARG3)
43900
44000
44100 OF THE FUNCTION JOIN:23 INTO LISP. FUNCTION NAMES WILL
44200 BE QUERIED IN PREORDER, AS NEEDED.
44300
44400 DRAW A LINE FROM THE FUNCTION CALL OF THE FUNCTION JOIN:23 TO THIS NEW
44500 PIECE OF CODE, WHICH IS ITS BODY:
44600
44700 (JOIN:23
44800 (LAMBDA (ARG1 ARG2 ARG3)
44900 (COMMENT IN ALL CALLS TO DATE, ARG1 IS INSTANTIATED AS
45000 COMPARE:24 POSSIBLE:NAME:OF:CLASS:OBJECTS:20 ELEMENT:OBJECTS:11))
45100 (COMMENT IN ALL CALLS TO DATE, ARG2 IS INSTANTIATED AS
45200 COMPARE:25 POSSIBLE:NAME:OF:CLASS:CLASSNAME:21 ELEMENT:CLASSNAME:13))
45300 (COMMENT IN ALL CALLS TO DATE, ARG3 IS INSTANTIATED AS
45400 COMPARE:26 POSSIBLE:NAME:OF:CLASS:RELNS:22 ELEMENT:RELNS:15))
45500 (AND ARG1 ARG2 ARG3)))
45600
45700 (COMMENT POSSIBLE:NAME:OF:CLASS:OBJECTS:20 IS NOT A BEING YET)
45800 (COMMENT ELEMENT:OBJECTS:11 IS NOT A BEING YET)
45900
46000 MOVE CURSOR TO ( COMPARE:26 TYPE OF ( COMPARE))
46100 SORRY TO BOTHER YOU, BUT I CAN NO LONGER DEFER THIS DICHOTOMY DECISION:
46200 (( COMPARING MAY INVOLVE A FUNCTION
46300 APPLIED DIRECTLY TO THE TWO ARGUMENTS)
46400 ( COMPARING MAY INVOLVE APPLYING A
46500 FUNCTION TO CORRESPONDING PAIRS OF
46600 SUBPARTS OF THE OBJECTS, AND FINALLY
46700 JOINING TOGETHER ALL THESE
46800 SUB-COMPARISONS' RESULTS)
46900 (ABOVE, ARG1 REFERS TO
47000 POSSIBLE:NAME:OF:CLASS:RELNS:22)
47100
47200 AHA!!!! I'VE RESOLVED IT MYSELF!!! NO NEED TO INTERACT WITH THE SLOW
47300 USER CHANNEL AFTER ALL!!!
47400
47500 PUP IS NOW GOING TO ENCODE THE PIECE
47600 (PROGN (COMMENT HERE WE MAY LATER WANT TO PUT SOME ASSIGNMENTS,
47700 REWRITES, AND ITERATIVE STATEMENTS)
47800 (COND ((NOT (FORSOME RELATION IN POSSIBLE:NAME:OF:CLASS:RELNS:22
47900 (RECOGNIZE:# RELATION ELEMENT:RELNS:15)))
48000 T)
48100 (T NIL)))
48200
48300 OF THE FUNCTION COMPARE:26 INTO LISP. FUNCTION NAMES WILL
48400 BE QUERIED IN PREORDER, AS NEEDED.
48500
48600 MOVE CURSOR TO ( CONTRADICTS:27 TYPE OF ( RECOGNIZE:#))
48700 SORRY TO BOTHER YOU, BUT I CAN NO LONGER DEFER THIS SOMEOF DECISION:
48800 (PROBABILITY=1:#
48900 PROBABILITY=0:#
49000 PROBABILITY>0&<1:#)
49100 SINCE THE DECISION IS SOME:OF, TYPE ANY ORDERED SUBSET OF:
49200 (A .... PROBABILITY=1:#)
49300 (B .... PROBABILITY=0:#)
49400 (C .... PROBABILITY>0&<1:#)
49500
49600 USER: \4(A B C)\*
49700
49800
49900 (I RECOMMEND THAT POSSIBLE:NAME:OF:CLASS:RELNS:22 BE STRUCTURED INTO (AT
50000 LEAST ALONG ONE DIMENSION) THESE 3 PIECES:
50100 (PROBABILITY=1:#:PART:OF:POSSIBLE:NAME:OF:CLASS:RELNS:22
50200 PROBABILITY=0:#:PART:OF:POSSIBLE:NAME:OF:CLASS:RELNS:22
50300 PROBABILITY>0&<1:#:PART:OF:POSSIBLE:NAME:OF:CLASS:RELNS:22) .
50400 PLEASE TYPE BACK YES, NO, OR UNSURE.)
50500
50600 USER: \4YES\*
50700
50800 PUP WANTS USER TO TYPE IN NAME FOR ( PROBABILITY:1:#:PART:OF:POSSI
50900 -BLE:NAME:OF:CLASS:RELNS)
51000
51100 I DON'T KNOW ANY NAMES FOR ( PROBABILITY:1:#:PART:OF:POSSIBLE:NAME
51200 :OF:CLASS:RELNS), SO YOU'LL HAVE TO
51300 TYPE A BRAND NEW NAME IN TO ME.
51400 USER: \4YES:RELNS\*
51500
51600 THE NAME CHOSEN IS YES:RELNS:28
51700
51800 .
51900 .
52000 .
52100
52200 DRAW A LINE FROM THE FUNCTION CALL (CONTRADICTS:27 RELATION ELEMENT:REL
52300 -NS:15) OF THE FUNCTION CONTRADICTS:27 TO THIS NEW PIECE OF CODE, WHICH
52400 IS ITS BODY:
52500
52600 (CONTRADICTS:27
52700 (LAMBDA (ARG1 ARG2)
52800 (COMMENT IN ALL CALLS TO DATE, ARG1 IS INSTANTIATED AS RELATION)
52900 (COMMENT IN ALL CALLS TO DATE, ARG2 IS INSTANTIATED AS ELEMENT:RELNS:15)
53000 (COND
53100 ((MEMBER ARG1 YES:RELNS:28)
53200 (COMMENT ARG1 OCCURS WITH PROBABILITY 1, SO IT HAD
53300 BETTER BE IN ARG2, WHICH IS
53400 THE RELEVANT PIECE OF THE WORLD)
53500 (NOT (MEMBER ARG1 ARG2)))
53600 ((MEMBER ARG1 NO:RELNS:29)
53700 (COMMENT SINCE ARG1 SHOULD NEVER OCCUR, WE HAVE A
53800 CONTRADICTION IFF IT IS A
53900 MEMBER OF ARG2, WHICH IS
54000 THE RELEVANT PIECE OF THE WORLD)
54100 (MEMBER ARG1 ARG2))
54200 (T (COMMENT WE MAY OR MAY NOT HAVE ARG1 IN ARG2; EITHER
54300 CASE IS ALLOWABLE; SO WE
54400 NEVER HAVE A CONTRADICTION)
54500 NIL))))
54600
54700 PUP: (PUP WORKED ON SOMETHING IMPROBABLE, NAMELY (IN ALL CODE GENERATED,
54800 POSSIBLE:NAME:OF:CLASS:RELNS:22 SHOULD BE
54900 REPLACED BY (APPEND YES:RELNS:28 NO:RELNS:29 MAYBE:RELNS:30)),
55000 AND HERE IS WHAT WE FINALLY DID ABOUT IT: (WE REPLACED
55100 ALL OCCURRENCES OF POSSIBLE:NAME:OF:CLASS:RELNS:22 BY
55200 (APPEND YES:RELNS:28 NO:RELNS:29 MAYBE:RELNS:30)))
55300
55400
55500 MOVE CURSOR TO ( MODIFY:STRUCTURE:7 TYPE OF ( MODIFY:STRUCTURE))
55600
55700 SORRY TO BOTHER YOU, BUT I CAN NO LONGER DEFER THIS SUBSETOF DECISION:
55800 (CONDITIONAL:INSERTION
55900 CONDITIONAL:DELETION
56000 COMPLEX:ALTERATION)
56100 SINCE THE DECISION IS SUBSET:OF, TYPE ANY ORDERED SUBSET OF:
56200 (A .... CONDITIONAL:INSERTION)
56300 (B .... CONDITIONAL:DELETION)
56400 (C .... COMPLEX:ALTERATION)
56500
56600 USER: \4(A C)\*
56700
56800 DRAW A LINE FROM THE FUNCTION CALL (MODIFY:STRUCTURE:7 NAME:OF:CLASS) OF
56900 THE FUNCTION MODIFY:STRUCTURE:7 TO THIS NEW PIECE OF CODE, WHICH IS
57000 ITS BODY:
57100
57200 (MODIFY:STRUCTURE:7
57300 (LAMBDA (ARG1)
57400 (COMMENT IN ALL CALLS TO DATE, ARG1 IS INSTANTIATED AS NAME:OF:CLASS)
57500 (COMMENT IN ALL CALLS TO DATE, ARG2 IS INSTANTIATED AS NIL)
57600 (CONDITIONAL:INSERTION:31 ARG1 ARG2)
57700 (COMPLEX:ALTERATION:32 ARG1 ARG2)))
57800
57900 I HAVE DECIDED TO KEEP POSSIBLE:NAME:OF:CLASS STRUCTURED
58000 USING THE PROPERTY LIST FEATURE OF LISP.
58100 FOR THIS REASON, I NEED TO HAVE A NAME FOR EACH
58200 PROPERTY (CORRESPONDING TO EACH SUBPART OF POSSIBLE:NAME:OF:CLASS) :
58300
58400 \5<This is the end of the example fragments of dialogue>\*
00100 .FILL
00200
00300 \5Below is the same piece of dialogue set off by lines of asterisks on
00400 page A5.2. It occupied only seven lines of the preceding excerpt, but
00500 below it occupies eight pages. The user may interrupt after each BEING
00600 receives control, and often does. When in an interrupt,
00700 the user is prompted by\* REQUEST: \5, after which he may type in a
00800 query. This will typically be the name of a BEING part, which is then
00900 "asked" of the current BEING. The active BEINGs are kept on a stack,
01000 and typing CH will print out this stack. Typing OLDER or YOUNGER lets
01100 the user crawl around this stack; the question he types in is by default
01200 put to the BEING indicated by the stack marker (when printed, this BEING
01300 name is surrounded by asterisks). \*
01400
01500 .NOFILL
01600
01700 INTERRUPT? \4YES
01800 \*REQUEST: \4CH
01900 \*NIL *** CHOOSE:FROM *** (WRITE:PROGRAM SERVE)
02000 \5This last request, CH, asked PUP6 to type out the control history;
02100 who called who, etc. In the current case, this is simply a stack.
02200 The present BEING is CHOOSE:FROM, and it is delimited by asterisks.
02300 It was called by WRITE:PROGRAM which was called by SERVE.\*
02400
02500 REQUEST: \4WHAT
02600 \*(CHOOSE THE BEST BEING FROM THE SET (OBTAIN:USABLE:INFORMATION
02700 USE:INFORMATION
02800 FILL:IN:UNDEFINED:SECTION
02900 CLARIFY:IMPROBABLE:SITUATION
03000 ADAPT:PRECONCEIVED:FUNCTION
03100 FIX:INCORRECT:PIECE )
03200 OF BEINGS)
03300
03400 REQUEST: \4WHY
03500 \*(BECAUSE THE FLOW OF CONTROL OF A PROGRAM MUST BE DETERMINATE)
03600
03700 REQUEST: \4OLDER
03800 \*WRITE:PROGRAM
03900
04000 REQUEST: \4CH
04100 \*(CHOOSE:FROM) *** WRITE:PROGRAM *** (SERVE)
04200
04300 REQUEST: \4WHAT
04400 \*(WRITE A PROGRAM WHICH DOES (CONCEPT:FORMATION))
04500 \5 <notice the effect of saying\* \4OLDER\* \5; questions are now
04600 directed to WRITE:PROGRAM instead of to CHOOSE:FROM.>\*
04700
04800 REQUEST: \4WHY
04900 \*(FUNDAMENTAL DRIVE TO OBEY USER; ALSO, IT IS NECESSARY THAT CODE BE
05000 WRITTEN TO DO (CONCEPT:FORMATION) IN ORDER THAT
05100 THE TASK (CONCEPT:FORMATION) MIGHT BE COMPLETED;
05200 ALSO, EXAMINE SPEC:WHY)
05300
05400 REQUEST: \4SPEC:WHY
05500 \*(WE CALL THE FIRST BEING WHICH CAN BRING ABOUT THE EFFECT
05600 (TYPE OF((CONCEPT:FORMATION) HAS BEEN STUDIED)))
05700
05800 REQUEST: \4HOW
05900 \*(CREATE SPECIALIZED LISP CODE WHICH WILL DO (CONCEPT:FORMATION))
06000
06100 REQUEST: \4?
06200 \*
06300 YOUR OPTIONS ARE AS FOLLOWS:
06400
06500 QUIT END THE INTERRUPT
06600 BEING PRINT NAME OF CURRENT BEING
06700 DEMONS PRINT SET OF DEMONS CURRENTLY ACTIVE
06800 CONTROL:HISTORY PRINT LIST OF BEINGS IN CONTROL, THE PATH FROM THE
06900 CURRENT BEING BACK TO THE BEGINNING OF THE PROGRAM
07000 OLDER CONSIDER THE BEING WHICH CALLED THE CURRENT ONE
07100 YOUNGER CONSIDER THE BEING WHICH THE CURRENT ONE CALLED
07200 OLDEST CONSIDER THE FIRST BEING IN CONTROL
07300 YOUNGEST CONSIDER THE LAST BEING IN CONTROL
07400 SPEC:WHEN AN EVALUATED VERSION OF 'WHEN'
07500 FAIL END THE INTERRUPT AND CAUSE CURRENT BEING TO FAIL
07600 NEW:LEVEL CHANGE THE USER:INTERRUPT LEVEL
07700 SPEC:WHY PRINT OUT THE SPECIFIC REASON(S) THAT THIS BEING WAS
07800
07900 TYPING ONE OF THESE WILL PRINT OUT WRITE:PROGRAM'S ANSWER TO THAT
08000 QUESTION:
08100 (IDEN IMPLICIT:ARGS EXPLICIT:ARGS EXPLICIT:ARGS:CHECK NLAMBDA
08200 NON:EVAL:ARGS WHAT HOW WHY SPEC:WHY MAIN:EFFECTS MINOR:EFFECTS WHEN
08300 META:CODE COMMENTS PRE:REQUISITES CO:REQUISITES POST:REQUISITES DEMONS
08400 AFFECTS COMPLEXITY:VECTOR GENERALIZATIONS SPECIALIZATIONS ALTERNATIVES
08500 PREDICATE DATA:STRUCTURE ENCODABLE INHIBIT:CURRENT:DEMONS FORM:CHANGING)
08600
08700 REQUEST: \4SPEC:WHEN
08800 \*((T IS T SO WE DO ADD IN THE WEIGHT (COND ((MEMBER TASK ABLE:PUP:LIST)
08900 -75) (T 40))
09000 WHICH IN THE CURRENT CASE IS 40;
09100 THE EXPLANATION IS (BECAUSE A PRE:EXISTING ABILITY TO DO
09200 (CONCEPT:FORMATION) IMPLIES THAT WRITING A NEW
09300 PROGRAM TO ACCOMPLISH IT IS SUPERFLUOUS AND,
09400 CONVERSELY, THE INABILITY TO
09500 DO ( CONCEPT:FORMATION) ABDUCTIVELY
09600 ENCOURAGES US THAT WE ARE ON THE RIGHT TRACK))
09700 ((MEMBER TASK WRITTEN:PROGRAMS:LIST) IS NIL, SO WE DONT ADD IN THE
09800 WEIGHT -80 WHICH IN THE CURRENT CASE IS -80 ;
09900 THE EXPLANATION IS (BECAUSE WE ARE NOT MUCH AFTER EFFICIENCY, AND
10000 IF A PROGRAM ALREADY EXISTS, THEN WE SHOULD USE IT))
10100 ((MEMBER ( PUP IS ABOUT TO WRITE A PROGRAM TO DO (TASK)) AWARE:USER:LIST)
10200 IS NIL SO WE DONT ADD IN THE WEIGHT 70
10300 WHICH IN THE CURRENT CASE IS 70 ;
10400 THE EXPLANATION IS (BECAUSE WE GO BY THE OLD
10500 ENGLISH LEGAL RULE THAT SILENCE SIGNIFIES APPROVAL))
10600 (T IS T SO WE DO ADD IN THE WEIGHT (COND (NEW:INFO:LIST -120)
10700 (T 40)) WHICH IN THE CURRENT CASE IS 40 ;
10800 THE EXPLANATION IS (BECAUSE WE SHOULD USE UP THE NEW INFORMATION BEFORE
10900 WRITING PROGRAMS .
11000 ALSO: BECAUSE IF NO NEW INFO IS PRESENT,
11100 THEN WE NEEDN'T FEEL GUILTY ABOUT STARTING TO WRITE
11200 A PROGRAM)))
11300 (THE FINAL WHEN VALUE IS THUS 80)
11400
11500 REQUEST: \4CH
11600 \*(CHOOSE:FROM) *** WRITE:PROGRAM *** (SERVE)
11700
11800 REQUEST: \4OLDER
11900 \*SERVE
12000
12100 REQUEST: \4CH
12200 \*(CHOOSE:FROM WRITE:PROGRAM) *** SERVE *** NIL
12300
12400 REQUEST: \4WHAT
12500 \*(DO ANYTHING THE USER ASKS)
12600
12700 REQUEST: \4WHY
12800 \*(FUNDAMENTAL DRIVE TO SERVE THE USER)
12900
13000 REQUEST: \4HOW
13100 \*(GET A TASK FROM THE USER)
13200
13300 REQUEST: \4QUIT
13400
13500 \*INTERRUPT? \4Y
13600 \*
13700 WRONG; TYPE YES OR NO ......... INTERRUPT? \4YES
13800
13900 \*REQUEST: \4BEING
14000 \*BETTER
14100
14200 REQUEST: \4WHAT
14300 \*(DECIDE WHICH OF (USE:INFORMATION (QUOTE PGM))
14400 (OBTAIN USABLE INFORMATION (QUOTE PGM))
14500 IS MORE A PROPOS TO TRY)
14600
14700 REQUEST: \4WHY
14800 \*(PUP CAN ONLY TRY AT MOST ONE OF USE:INFORMATION AND
14900 OBTAIN:USABLE:INFORMATION AT A TIME)
15000
15100 REQUEST: \4HOW
15200 \*(COMPARE THE WHEN PARTS OF USE:INFORMATION AND OBTAIN:USABLE:INFORMATION
15300 AND, IF NECESSARY, COMPARE THEIR COMPLEXITY VECTORS)
15400
15500 REQUEST: \4COMPLEXITY:VECTOR
15600 \*(.5 .5 .5 .5 .1)
15700
15800 REQUEST: \4CH
15900 \*NIL *** BETTER *** (CHOOSE:FROM WRITE:PROGRAM SERVE)
16000
16100 REQUEST: \4QUIT
16200
16300 \*INTERRUPT? \4NO
16400 \*INTERRUPT? \4NO
16500 \*INTERRUPT? \4NO
16600 \*INTERRUPT? \4YES
16700
16800 \*REQUEST: \4WHAT
16900 \*(SATISFY THE SIMPLE SUBGOAL (TYPE OF ((CONCEPT:FORMATION) HAS BEEN
17000 STUDIED)))
17100
17200 REQUEST: \4HOW
17300 \*(PASS CONTROL TO THE SIMPLEST SUFFICIENT BEING)
17400
17500 REQUEST: \4AFFECTS
17600 \*(((STUDY:TYPE (CONCEPT:FORMATION)) POSSIBLE:CALLED)
17700 (TRY:BEING CALLED)
17800 (SORT CALLED)
17900 (A:BEING:ORDER CALLED))
18000
18100 REQUEST: \4CH
18200 \*NIL *** SATISFY *** (FILL:IN:UNDEFINED:SECTION CHOOSE:FROM WRITE:PROGRAM
18300 SERVE)
18400
18500 REQUEST: \4OLDER
18600 \*FILL:IN:UNDEFINED:SECTION
18700
18800 REQUEST: \4WHAT
18900 \*(FILL IN AN UNDEFINED SECTION OF CODE AND ADD IT TO THE PROGRAM PGM)
19000
19100 REQUEST: \4WHY
19200 \*(BECAUSE ALL PIECES OF CODE MUST BE DEFINED OR THE PROGRAM WONT RUN)
19300
19400 REQUEST: \4HOW
19500 \*(CHOOSE THE SIMPLEST UNDEFINED PIECE AND ENCODE IT)
19600
19700 REQUEST: \4CHOICE
19800 \*( CF:1 TYPE OF ( CONCEPT:FORMATION))
19900
20000 REQUEST: \4QUIT
20100
20200 \*INTERRUPT? \4YES
20300
20400 \*REQUEST: \4BEING
20500 \*REINVESTIGATE:DECISION
20600
20700 REQUEST: \4WHAT
20800 \*(RESOLVE THE DECISION
20900 (BOOLEAN (SUBJECT:SPECIFIC BEHAVIOR MAY BE REQUIRED OF CF:1)
21000 AFFECTS (WHETHER PARAMETERS
21100 DESCRIBING AN INDIVIDUAL MUST BE READ IN BY CF:1)
21200 WHEN (BEFORE ANY ROUTINES ARE FINALIZED)
21300 WHY (BECAUSE ANY PROCESSING
21400 ROUTINE MAY HAVE TO DEPEND UPON SOME INDIVIDUAL PARAMETERS)
21500 CONCEPT:FORMATION)
21600 BECAUSE (SETINTERSECTION UNDEFINED:SECTION:LIST DOING:PUP:LIST)
21700 IS NOW NONNULL; FIRST TRY TO DEFER IT A LITTLE LONGER)
21800
21900 REQUEST: \4HOW
22000 \*(TRY TO DEFER UNTIL ;ELSE TRY TO RESOLVE IT WITH PRESENT KNOWLEDGE ;
22100 ELSE ASK THE USER TO RESOLVE IT)
22200
22300 REQUEST: \4QUIT
22400
22500 \*INTERRUPT? \4YES
22600
22700 \*REQUEST: \4CH
22800 \*NIL *** DEFER:DECISION *** (REINVESTIGATE:DECISION FILL:IN:UNDEFINED:S-
22900 -ECTION CHOOSE:FROM WRITE:PROGRAM SERVE)
23000
23100 REQUEST: \4QUIT
23200
23300 \*INTERRUPT? \4YES
23400
23500 \*REQUEST: \4CH
23600 \*NIL *** UTILIZE *** (WHEN:NEXT DEFER:DECISION REINVESTIGATE:DECISION
23700 FILL:IN:UNDEFINED:SECTION CHOOSE:FROM
23800 WRITE:PROGRAM SERVE)
23900
24000 REQUEST: \4HOW
24100 \*(SEARCH THROUGH NIL FOR APPLICABLE RULES)
24200
24300 REQUEST: \4QUIT
24400
24500 \*INTERRUPT? \4YES
24600
24700 \*REQUEST: \4CH
24800 \*NIL *** RESOLVE:DECISION *** (DEFER:DECISION REINVESTIGATE:DECISION
24900 FILL:IN:UNDEFINED:SECTION CHOOSE:FROM
25000 WRITE:PROGRAM SERVE)
25100
25200 REQUEST: \4WHY
25300 \*(AS FAR AS WE KNOW AT THIS INSTANT, THE DECISION
25400 (BOOLEAN (SUBJECT:SPECIFIC BEHAVIOR MAY BE REQUIRED OF CF:1) )
25500 CANNOT BE DEFERRED ANY LONGER)
25600
25700 REQUEST: \4HOW
25800 \*(TRY TO RESOLVE (BOOLEAN (SUBJECT:SPECIFIC BEHAVIOR MAY BE REQUIRED OF
25900 CF:1)) WITH PRESENT KNOWLEDGE; IF THAT FAILS, ASK
26000 THE USER ABOUT IT)
26100
26200 REQUEST: \4QUIT
26300
26400 \*INTERRUPT? \4YES
26500
26600 \*REQUEST: \4CH
26700 \*NIL *** ASK:USER:ABOUT *** (RESOLVE:DECISION DEFER:DECISION REINVESTIG-
26800 -ATE:DECISION FILL:IN:UNDEFINED:SECTION
26900 CHOOSE:FROM WRITE:PROGRAM SERVE)
27000
27100 REQUEST: \4WHAT
27200 \*(ASK THE USER TO RESOLVE DECISION ((BOOLEAN (SUBJECT:SPECIFIC BEHAVIOR
27300 MAY BE REQUIRED OF CF:1))
27400
27500 REQUEST: \4WHY
27600 \*(BECAUSE PUP CANNOT RESOLVE IT, BUT MUST AT THIS TIME)
27700
27800 REQUEST: \4QUIT
27900 \*
28000
28100 MOVE CURSOR TO ( CF:1 TYPE OF ( CONCEPT:FORMATION))
28200
28300 SORRY TO BOTHER YOU, BUT I CAN NO LONGER DEFER THIS BOOLEAN DECISION:
28400 (SUBJECT:SPECIFIC BEHAVIOR MAY BE REQUIRED
28500 OF CF:1)
28600 SINCE THE DECISION IS BOOLEAN, JUST ANSWER YES OR NO.
28700
28800 SHOULD I DISCUSS RAMIFICATIONS?\4NO\* \5 If the user answered
28900 affirmatively, copious amounts of data would appear, describing
29000 what this choice is, the effects of each possible answer, why it
29100 can't wait, who wanted this done, and so on. \*
29200
29300 NOW TYPE YOUR ANSWER: \4NO\*
29400
29500 OK, READY TO MOVE ON NOW.
29600
29700
29800 \5Here are a few more direct queries to BEINGS during the dialogue:\*
29900
30000 REQUEST: \4UNDEFINED:SECTION:LIST
30100 \*(( PARTITION:A:DOMAIN) ( PAD:2 TYPE OF ( PARTITION:A:DOMAIN)))
30200
30300 REQUEST: \4AWARE:USER:LIST
30400 \*(( THE NAME OF THE PROGRAM TO DO ( CONCEPT:FORMATION) IS CF:1)
30500 ( PUP AND USER ARE ABLE TO REFER TO
30600 ( CONCEPT:FORMATION) AS TASK:NAME WHICH IS CF:1))
30700
30800 REQUEST: \4(PLUS 2 2)\* \5 Converse to DWIM: we try to understand; if
30900 we can't, THEN we try to EVAL the expression.
31000 \*4
31100
31200 REQUEST: \4DEMONS
31300 \*(FRINGE:OF:CONCIOUSNESS:DEMON PSYCHOLOGY:DEMON PROGRAM:WRITING:DEMONS
31400 DEFERRAL:DEMON REINVESTIGATION:DEMON IDIOM:DEMON
31500 SPECIFICITY:CHECK:DEMON FORGETFUL:USER:DEMON)
31600 THE DEMON STACK IS ((PROGRAM:WRITING:DEMONS DEFERRAL:DEMON REINVESTIGATI-
31700 -ON:DEMON IDIOM:DEMON SPECIFICITY:CHECK:DEMON
31800 FORGETFUL:USER:DEMON)
31900 (FORGETFUL:USER:DEMON))
32000
32100 REQUEST: \4BEING:STACK
32200 \*(WRITE:PROGRAM SERVE)
32300
32400 REQUEST: \4NEW:LEVEL
32500 \*
32600 HELLO THERE. I AM READY TO START .
32700
32800 HOW OFTEN SHOULD I LET YOU INTERRRUPT ME, TO ASK ME ABOUT WHAT I'M
32900 DOING? TYPE A DIGIT, AS EXPLAINED BELOW:
33000
33100 0 NEVER (ULTIMATE PRODUCTION-RUN MODE)
33200 2 A COUPLE OF TIMES DURING THE COURSE OF WRITING A PROGRAM
33300 4 DURING EACH PHASE OF WRITING A PROGRAM
33400 6 DURING THE WRITING OF EACH NONTRIVIAL SUBFUNCTION OF A PROGRAM
33500 8 DURING EACH PHASE OF WRITING EACH SUBFUNCTION OF A PROGRAM
33600 10 EACH TIME A BEING TRANSFERS CONTROL (ULTIMATE DEBUG MODE)
33700
33800 OK, NOW TYPE A DIGIT... \4NO\*
33900
34000 *** ERROR *** YOU MUST TYPE ONE EVEN INTEGER FROM 0 TO 10
34100 TRY AGAIN:
34200 \48\*
34300
34400 REQUEST: \4QUIT
34500 \*
34600
34700 .FILL
34800
34900 \5This concludes the "frequent-interrupt mode" excerpt. In the terminology
35000 of NEW:LEVEL, this was at interrupt level 10, while the earlier excerpts
35100 were at level 0. Recall that this last excerpt was but seven lines in the
35200 earlier excerpt, which in turn was only 3% of the actual 300-page dialogue.
35300 The reader who has read through to this point will probably agree that
35400 dialogue problems are central
35500 to automatic programming.\*